Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.AniTool = undefined;
var exp_AniTool = function () {
  function _ctor() { }
  _ctor.prototype.showBtnUpAni = function (t, e, o) {
    // 如果 o 未定义，设置默认值为 "cubicIn"
    if (o === undefined) {
      o = "cubicIn";
    }

    // 返回一个 Promise 对象
    return new Promise(function (resolve) {
      // 移除组件并设置节点位置
      t.removeComponent(cc.Widget);
      t.y = -(0.5 * cc.winSize.height + 0.5 * t.height + 30);

      // 获取当前节点的位置
      const initialPosition = t.getPosition();
      t.active = true; // 激活节点

      const buttonComponent = t.getComponent(cc.Button);
      if (buttonComponent) {
        buttonComponent.interactable = false; // 禁用按钮交互
      }

      // 创建动画， tween 到目标位置
      cc.tween(t)
        .to(0.5, { y: e }, { easing: o }) // 进行平移
        .call(function () {
          if (buttonComponent) {
            buttonComponent.interactable = true; // 动画完成后启用按钮交互
          }
          resolve(initialPosition); // 解决 Promise，返回初始位置
        })
        .start(); // 启动动画
    });
  };
  _ctor.prototype.hideBtnDownAni = function (t, e) {
    // 如果 e 未定义，则设置默认值为 "cubicOut"
    if (e === undefined) {
      e = "cubicOut";
    }

    // 返回一个 Promise 对象
    return new Promise(function (resolve) {
      const buttonComponent = t.getComponent(cc.Button); // 获取按钮组件
      const initialPosition = t.getPosition(); // 获取当前节点位置

      // 禁用按钮交互
      if (buttonComponent) {
        buttonComponent.interactable = false;
      }

      // 创建动画，tween 到目标位置
      cc.tween(t)
        .to(0.5, {
          y: -(0.5 * cc.winSize.height + 0.5 * t.height + 30) // 计算目标 Y 值
        }, {
          easing: e // 添加 easing 动画效果
        })
        .call(function () {
          // 动画完成后执行的回调函数
          if (buttonComponent) {
            buttonComponent.interactable = true; // 启用按钮交互
          }
          t.active = false; // 隐藏节点
          resolve(initialPosition); // 解决 Promise，返回初始位置
        })
        .start(); // 启动动画
    });
  };
  _ctor.prototype.showBtnBubbleAni = function (t, e, o, n) {
    // 设置默认值
    if (e === undefined) e = 0.5; // 缩放时间
    if (o === undefined) o = false; // 交互状态
    if (n === undefined) n = 0; // 延迟时间

    // 返回一个 Promise 对象
    return new Promise(function (resolve) {
      t.scale = 0; // 初始化节点缩放为 0
      t.active = true; // 激活节点

      const buttonComponent = t.getComponent(cc.Button); // 获取按钮组件
      if (buttonComponent) {
        buttonComponent.interactable = false; // 禁用按钮交互
      }

      // 创建缩放动画
      cc.tween(t)
        .delay(n) // 延迟
        .to(e, {
          scale: 1 // 动画目标缩放
        }, {
          easing: "backOut" // 设置缓动效果
        })
        .call(function () {
          if (buttonComponent) {
            buttonComponent.interactable = !o; // 根据 o 设置按钮交互状态
          }
          resolve(); // 解决 Promise
        })
        .start(); // 启动动画
    });
  };
  _ctor.prototype.hideBtnBubbleAni = function (t, e, o, n) {
    // 设置默认值
    if (e === undefined) e = 0.5; // 动画持续时间
    if (o === undefined) o = false; // 节点激活状态
    if (n === undefined) n = 0; // 动画延迟时间

    // 返回一个 Promise 对象
    return new Promise(function (resolve) {
      const buttonComponent = t.getComponent(cc.Button); // 获取按钮组件
      if (buttonComponent) {
        buttonComponent.interactable = false; // 禁用按钮交互
      }

      // 创建缩放动画
      cc.tween(t)
        .delay(n) // 添加延迟
        .to(e, {
          scale: 0 // 动画目标缩放
        }, {
          easing: "backIn" // 设置缓动效果
        })
        .call(function () {
          t.active = o; // 根据 o 设置节点的激活状态
          resolve(); // 解决 Promise
        })
        .start(); // 启动动画
    });
  };
  _ctor.prototype.btnsShowBubbleAni = function (t, e, o) {
    // 设置默认值
    if (e === undefined) e = 0.5; // 动画持续时间
    if (o === undefined) o = false; // 按钮交互状态

    // 返回一个 Promise 对象
    return new Promise(function (resolve) {
      t.active = true; // 激活节点

      // 遍历子节点
      t.children.forEach(function (child, index) {
        child.scale = 0; // 初始化子节点的缩放为 0
        child.active = true; // 激活子节点

        const buttonComponent = child.getComponent(cc.Button); // 获取按钮组件
        if (buttonComponent) {
          buttonComponent.interactable = false; // 禁用按钮交互
        }

        // 创建缩放动画
        cc.tween(child)
          .delay(0.3 * index) // 添加延迟
          .to(e, {
            scale: 1 // 动画目标缩放
          }, {
            easing: "backOut" // 设置缓动效果
          })
          .call(function () {
            if (buttonComponent) {
              buttonComponent.interactable = !o; // 根据 o 设置按钮交互状态
            }

            // 如果是最后一个子节点，解决 Promise
            if (index === t.childrenCount - 1) {
              resolve();
            }
          })
          .start(); // 启动动画
      });
    });
  };
  _ctor.prototype.btnsHideBubbleAni = function (t, e, o) {
    // 设置默认值
    if (e === undefined) e = 0.5; // 动画持续时间
    if (o === undefined) o = false; // 目标激活状态

    // 返回一个 Promise 对象
    return new Promise(function (resolve) {
      // 遍历子节点
      t.children.forEach(function (child, index) {
        const buttonComponent = child.getComponent(cc.Button); // 获取按钮组件
        if (buttonComponent) {
          buttonComponent.interactable = false; // 禁用按钮交互
        }

        // 创建缩放动画
        cc.tween(child)
          .delay(0.3 * index) // 添加延迟
          .to(e, {
            scale: 0 // 动画目标缩放为 0
          }, {
            easing: "backIn" // 设置缓动效果
          })
          .call(function () {
            child.active = o; // 根据 o 设置子节点的激活状态

            // 如果是最后一个子节点，解决 Promise
            if (index === t.childrenCount - 1) {
              t.active = o; // 根据 o 设置整个目标的激活状态
              resolve(); // 解决 Promise
            }
          })
          .start(); // 启动动画
      });
    });
  };
  _ctor.prototype.btnHorizontalComeIn = function (t, e, o, n) {
    // 设置默认值
    if (e === undefined) e = 0.5; // 动画持续时间
    if (o === undefined) o = -1; // 移动方向（负值控制方向）
    if (n === undefined) n = false; // 按钮交互状态

    // 返回一个 Promise 对象
    return new Promise(function (resolve) {
      t.active = true; // 激活节点
      const buttonComponent = t.getComponent(cc.Button); // 获取按钮组件
      if (buttonComponent) {
        buttonComponent.interactable = false; // 禁用按钮交互
      }

      const initialPosition = t.getPosition(); // 获取初始位置
      t.x = (cc.winSize.width + t.width) * o; // 设置目标位置

      // 创建移动动画
      cc.tween(t)
        .to(e, {
          x: initialPosition.x // 移动到初始位置
        }, {
          easing: cc.easing.backOut // 设置缓动效果
        })
        .call(function () {
          if (buttonComponent) {
            buttonComponent.interactable = !n; // 恢复按钮交互状态
          }
          resolve(); // 解决 Promise
        })
        .start(); // 启动动画
    });
  };
  _ctor.prototype.btnHorizontalGetOut = function (t, e, o, n) {
    // 设置默认值
    if (e === undefined) e = 0.5; // 动画持续时间
    if (o === undefined) o = -1; // 移动方向（负值控制方向）
    if (n === undefined) n = false; // 节点激活状态

    // 返回一个 Promise 对象
    return new Promise(function (resolve) {
      const buttonComponent = t.getComponent(cc.Button); // 获取按钮组件
      if (buttonComponent) {
        buttonComponent.interactable = false; // 禁用按钮交互
      }

      // 创建并启动移动动画
      cc.tween(t)
        .to(e, {
          x: (cc.winSize.width + t.width) * o // 目标位置
        }, {
          easing: cc.easing.backIn // 设置缓动效果
        })
        .call(function () {
          t.active = n; // 根据 n 设置节点的激活状态
          resolve(); // 解决 Promise
        })
        .start(); // 启动动画
    });
  };
  _ctor.prototype.btnsHorizontalComeIn = function (t, e, o, n) {
    // 设置默认值
    if (e === undefined) e = 0.5; // 动画持续时间
    if (o === undefined) o = -1; // 移动方向（负值控制方向）
    if (n === undefined) n = false; // 节点激活状态

    // 返回一个 Promise 对象
    return new Promise(function (resolve) {
      t.active = true; // 激活节点
      const layoutComponent = t.getComponent(cc.Layout); // 获取布局组件
      if (layoutComponent) {
        layoutComponent.enabled = false; // 禁用布局组件
      }

      // 遍历子节点
      t.children.forEach(function (child, index) {
        const buttonComponent = child.getComponent(cc.Button); // 获取按钮组件
        if (buttonComponent) {
          buttonComponent.interactable = false; // 禁用按钮交互
        }

        child.active = true; // 激活子节点
        const initialPosition = child.getPosition(); // 获取初始位置
        child.x = (cc.winSize.width + child.width) * o; // 设置目标位置

        // 创建并启动移动动画
        cc.tween(child)
          .delay(0.2 * index) // 添加延迟
          .to(e, {
            x: initialPosition.x // 动画目标位置
          }, {
            easing: cc.easing.backOut // 设置缓动效果
          })
          .call(function () {
            if (buttonComponent) {
              buttonComponent.interactable = !n; // 根据 n 设置按钮的交互状态
            }
            // 如果是最后一个子节点，启用布局组件并解决 Promise
            if (index === t.childrenCount - 1) {
              if (layoutComponent) {
                layoutComponent.enabled = true; // 启用布局组件
              }
              resolve(); // 解决 Promise
            }
          })
          .start(); // 启动动画
      });
    });
  };
  _ctor.prototype.btnsHorizontalGetOut = function (t, e, o, n) {
    // 设置默认值
    if (e === undefined) e = 0.5; // 动画持续时间
    if (o === undefined) o = -1; // 移动方向（负值控制方向）
    if (n === undefined) n = false; // 节点激活状态

    // 返回一个 Promise 对象
    return new Promise(function (resolve) {
      const layoutComponent = t.getComponent(cc.Layout); // 获取布局组件
      if (layoutComponent) {
        layoutComponent.enabled = false; // 禁用布局组件
      }

      // 遍历子节点
      t.children.forEach(function (child, index) {
        const buttonComponent = child.getComponent(cc.Button); // 获取按钮组件
        if (buttonComponent) {
          buttonComponent.interactable = false; // 禁用按钮交互
        }

        // 创建和启动移动动画
        cc.tween(child)
          .delay(0.2 * index) // 添加延迟
          .to(e, {
            x: (cc.winSize.width + child.width) * o // 目标位置计算
          }, {
            easing: cc.easing.backIn // 设置缓动效果
          })
          .call(function () {
            // 如果是最后一个子节点，启用布局组件并解决 Promise
            if (index === t.childrenCount - 1) {
              t.active = n; // 根据 n 设置节点的激活状态
              if (layoutComponent) {
                layoutComponent.enabled = true; // 启用布局组件
              }
              resolve(); // 解决 Promise
            }
          })
          .start(); // 启动动画
      });
    });
  };
  _ctor.prototype.btnsVerticalComeIn = function (t, e, o, n) {
    // 设置默认值
    if (e === undefined) e = 0.5; // 动画持续时间
    if (o === undefined) o = -1; // 移动方向
    if (n === undefined) n = false; // 按钮交互状态

    // 返回一个 Promise 对象
    return new Promise(function (resolve) {
      t.active = true; // 激活节点
      const layoutComponent = t.getComponent(cc.Layout); // 获取布局组件
      if (layoutComponent) {
        layoutComponent.enabled = false; // 禁用布局组件
      }

      // 遍历子节点
      t.children.forEach(function (child, index) {
        const buttonComponent = child.getComponent(cc.Button); // 获取按钮组件
        if (buttonComponent) {
          buttonComponent.interactable = false; // 禁用按钮交互
        }

        const initialPosition = child.getPosition(); // 获取初始位置
        child.y = (cc.winSize.height + child.height) * o; // 设置目标位置

        // 创建和启动移动动画
        cc.tween(child)
          .delay(0.2 * index) // 添加延迟
          .to(e, {
            y: initialPosition.y // 移动到初始 Y 位置
          }, {
            easing: cc.easing.backOut // 设置缓动效果
          })
          .call(function () {
            if (buttonComponent) {
              buttonComponent.interactable = !n; // 根据 n 设置按钮交互状态
            }
            // 如果是最后一个子节点，启用布局组件并解决 Promise
            if (index === t.childrenCount - 1) {
              if (layoutComponent) {
                layoutComponent.enabled = true; // 启用布局组件
              }
              resolve(); // 解决 Promise
            }
          })
          .start(); // 启动动画
      });
    });
  };
  _ctor.prototype.btnsVerticalGetOut = function (t, e, o, n) {
    // 设置默认值
    if (e === undefined) e = 0.5; // 动画持续时间
    if (o === undefined) o = -1; // 移动方向
    if (n === undefined) n = false; // 节点激活状态

    // 返回一个 Promise 对象
    return new Promise(function (resolve) {
      const layoutComponent = t.getComponent(cc.Layout); // 获取布局组件
      if (layoutComponent) {
        layoutComponent.enabled = false; // 禁用布局组件
      }

      // 遍历子节点
      t.children.forEach(function (child, index) {
        const buttonComponent = child.getComponent(cc.Button); // 获取按钮组件
        if (buttonComponent) {
          buttonComponent.interactable = false; // 禁用按钮交互
        }

        // 创建并启动移动动画
        cc.tween(child)
          .delay(0.2 * index) // 添加延迟
          .to(e, {
            y: (cc.winSize.height + child.height) * o // 目标位置
          }, {
            easing: cc.easing.backIn // 设置缓动效果
          })
          .call(function () {
            // 如果是最后一个子节点
            if (index === t.childrenCount - 1) {
              t.active = n; // 根据 n 设置节点的激活状态
              if (layoutComponent) {
                layoutComponent.enabled = true; // 启用布局组件
              }
              resolve(); // 解决 Promise
            }
          })
          .start(); // 启动动画
      });
    });
  };
  _ctor.prototype.allAroundWaggle = function (t, e, o) {
    // 设置默认值
    if (e === undefined) e = 0.05; // 动画持续时间
    if (o === undefined) o = 20; // 移动距离

    // 返回一个 Promise 对象
    return new Promise(function (resolve) {
      // 创建移动动画序列
      cc.tween(t)
        .sequence(
          cc.tween(t)
            .to(e, { y: t.y + o }) // 向上移动
            .to(e, { x: t.x + o, y: t.y - o }) // 右上移动
            .to(e, { x: t.x - o, y: t.y - o }) // 左上移动
            .to(e, { x: t.x - o, y: t.y + o }), // 左下移动

          // 第二组
          cc.tween(t)
            .to(e, { y: t.y + o, x: t.x + o }) // 右下移动
            .to(e, { x: t.x + o, y: t.y - o }) // 右上移动
            .to(e, { x: t.x - o, y: t.y - o }) // 左上移动
            .to(e, { x: t.x - o, y: t.y + o }), // 左下移动

          // 第三组
          cc.tween(t)
            .to(e, { y: t.y + o, x: t.x + o }) // 右下移动
            .to(e, { x: t.x + o, y: t.y - o }) // 右上移动
            .to(e, { x: t.x - o, y: t.y - o }) // 左上移动
            .to(e, { x: t.x - o, y: t.y + o }), // 左下移动

          // 第四组
          cc.tween(t)
            .to(e, { y: t.y + o, x: t.x + o }) // 右下移动
            .to(e, { y: t.y - o }) // 向下移动
        )
        .call(function () {
          resolve(); // 解决 Promise
        })
        .start(); // 启动动画
    });
  };
  _ctor.prototype.showHideDialogAnimation = function (t, e) {
    // 返回一个 Promise 对象
    return new Promise(function (resolve, reject) {
      // 检查目标节点是否存在且有效
      if (t && t.isValid) {
        if (e) {
          t.scale = 0; // 初始化缩放为 0

          // 创建并启动动画
          cc.tween(t).parallel(
            cc.tween(t).to(0.26, { scale: 1 }), // 在 0.26 秒内缩放到 1
            cc.tween(t)
              .by(0.117, { y: 250 }, { easing: "cubicOut" }) // 向上移动
              .by(0.26 * 0.55, { y: -250 }, { easing: "cubicIn" }) // 向下移动
          ).call(function () {
            resolve(null); // 解决 Promise
          }).start();
        } else {
          // 创建并启动另一组动画
          cc.tween(t).parallel(
            cc.tween(t).to(0.26, { scale: 0 }), // 在 0.26 秒内缩放到 0
            cc.tween(t)
              .by(0.26 * 0.55, { y: 250 }, { easing: "cubicOut" }) // 向上移动
              .by(0.117, { y: -250 }, { easing: "cubicIn" }) // 向下移动
          ).call(function () {
            resolve(null); // 解决 Promise
          }).start();
        }
      } else {
        reject(); // 如果条件不满足，拒绝 Promise
      }
    });
  };
  return _ctor;
}();
exports.AniTool = exp_AniTool;